/**
 * API工具类
 * 统一管理所有API请求
 */

const remoteBaseURL = 'https://yaotuss.com/api/v1';
const localBaseURL = 'http://localhost:3000/api/v1';
// API基础配置
const API_CONFIG = {
  baseURL: remoteBaseURL,
  timeout: 10000
}

/**
 * 通用请求方法
 * @param {Object} options 请求配置
 * @returns {Promise}
 */
function request(options) {
  return new Promise((resolve, reject) => {
    // 获取token
    const token = uni.getStorageSync('token')

    // 构建请求配置
    const config = {
      url: API_CONFIG.baseURL + options.url,
      method: options.method || 'GET',
      data: options.data || {},
      header: {
        'Content-Type': 'application/json',
        ...options.header
      },
      timeout: options.timeout || API_CONFIG.timeout
    }

    // 添加认证头
    if (token) {
      config.header.Authorization = `Bearer ${token}`
    }

    // 发送请求
    uni.request({
      ...config,
      success: (res) => {
        // 2xx状态码都认为是成功
        if (res.statusCode >= 200 && res.statusCode < 300) {
          resolve(res.data)
        } else {
          // 处理401错误 - 未授权/token过期
          if (res.statusCode === 401) {
            console.log('检测到401错误，清除登录信息并跳转到登录页')

            // 清除登录信息
            utils.clearAuth()

            // 显示提示信息
            uni.showToast({
              title: '登录已过期，请重新登录',
              icon: 'none',
              duration: 2000
            })

            // 延迟跳转到登录页面，避免与toast冲突
            setTimeout(() => {
              uni.reLaunch({
                url: '/pages/login/login'
              })
            }, 1000)

            // 返回特定的401错误
            reject(new Error('UNAUTHORIZED'))
            return
          }

          // 处理其他HTTP错误
          const error = new Error(`HTTP ${res.statusCode}: ${res.data?.message || '请求失败'}`)
          error.statusCode = res.statusCode
          error.responseData = res.data
          reject(error)
        }
      },
      fail: (err) => {
        console.error('请求失败:', err)
        reject(new Error('网络请求失败'))
      }
    })
  })
}

/**
 * 认证相关API
 */
export const authAPI = {
  /**
   * 微信登录
   * @param {string} code 微信登录code
   * @param {number} inviterId 邀请者ID（可选）
   * @param {Object} userProfile 用户信息（可选）
   */
  login(code, inviterId, userProfile) {
    const data = { code };
    if (inviterId) data.inviterId = inviterId;
    if (userProfile) data.userProfile = userProfile;

    return request({
      url: '/auth/login',
      method: 'POST',
      data
    })
  },

  /**
   * 刷新token
   * @param {string} token 旧token
   */
  refreshToken(token) {
    return request({
      url: '/auth/refresh',
      method: 'POST',
      data: { token }
    })
  },

  /**
   * 测试登录（开发环境使用）
   */
  testLogin() {
    return request({
      url: '/auth/test-login',
      method: 'POST'
    })
  },

  /**
   * 登出
   */
  logout() {
    return request({
      url: '/auth/logout',
      method: 'POST'
    })
  },

  /**
   * 手机号快捷登录（自动获取）
   * @param {string} code 微信登录code
   * @param {string} phoneCode 手机号授权code
   * @param {Object} userProfile 用户信息（可选）
   * @param {number} inviterId 邀请者ID（可选）
   */
  phoneLogin(code, phoneCode, userProfile, inviterId) {
    const data = { code, phoneCode };
    if (inviterId) data.inviterId = inviterId;
    if (userProfile) data.userProfile = userProfile;

    return request({
      url: '/auth/phone-login',
      method: 'POST',
      data
    })
  },

  /**
   * 获取手机号（安全方式）
   * @param {string} code 手机号授权code
   */
  getPhoneNumber(code) {
    return request({
      url: '/auth/get-phone-number',
      method: 'POST',
      data: { code }
    })
  },

  /**
   * 手机号登录（手动输入）
   * @param {string} code 微信登录code
   * @param {string} phoneNumber 手机号
   * @param {Object} userProfile 用户信息（可选）
   * @param {number} inviterId 邀请者ID（可选）
   */
  manualPhoneLogin(code, phoneNumber, userProfile, inviterId) {
    const data = { code, phoneNumber };
    if (inviterId) data.inviterId = inviterId;
    if (userProfile) data.userProfile = userProfile;

    return request({
      url: '/auth/manual-phone-login',
      method: 'POST',
      data
    })
  }
}

/**
 * 用户相关API
 */
export const userAPI = {
  /**
   * 获取当前用户信息
   */
  getCurrentUser() {
    return request({
      url: '/users/me'
    })
  },

  /**
   * 更新用户信息
   * @param {Object} userData 用户数据
   */
  updateUser(userData) {
    return request({
      url: '/users/me',
      method: 'PUT',
      data: userData
    })
  },

  /**
   * 上传用户头像
   * @param {string} filePath 文件路径
   */
  uploadAvatar(filePath) {
    return new Promise((resolve, reject) => {
      const token = uni.getStorageSync('token')

      uni.uploadFile({
        url: `${API_CONFIG.baseURL}/users/me/avatar`,
        filePath: filePath,
        name: 'avatar',
        header: {
          'Authorization': token ? `Bearer ${token}` : ''
        },
        success: (res) => {
          try {
            const data = JSON.parse(res.data)
            if (data.success) {
              resolve(data)
            } else {
              reject(new Error(data.message || '上传失败'))
            }
          } catch (error) {
            reject(new Error('响应解析失败'))
          }
        },
        fail: (error) => {
          reject(error)
        }
      })
    })
  },

  /**
   * 根据用户ID获取用户信息
   * @param {number|string} userId 用户ID
   */
  getUserById(userId) {
    return request({
      url: `/users/${userId}`
    })
  },

  /**
   * 获取我的发布列表
   * @param {Object} params 查询参数
   */
  getMyListings(params = {}) {
    const queryString = Object.keys(params)
      .map(key => `${key}=${encodeURIComponent(params[key])}`)
      .join('&')

    return request({
      url: `/users/me/listings${queryString ? '?' + queryString : ''}`
    })
  },

  /**
   * 获取邀请统计
   */
  getInviteStats() {
    return request({
      url: '/users/me/invite-stats'
    })
  },

  /**
   * 获取邀请记录
   * @param {Object} params 查询参数
   */
  getInviteRecords(params = {}) {
    const queryString = Object.keys(params)
      .map(key => `${key}=${encodeURIComponent(params[key])}`)
      .join('&')

    return request({
      url: `/users/me/invites${queryString ? '?' + queryString : ''}`
    })
  },

  /**
   * 标记审核结果为已查看
   * @param {string} type 类型：'listing'或'service'
   * @param {string} id 记录ID
   */
  markAuditViewed(type, id) {
    return request({
      url: '/users/me/mark-audit-viewed',
      method: 'POST',
      data: { type, id }
    })
  }
}

/**
 * 聊天相关API
 */
export const chatAPI = {
  /**
   * 获取群组列表
   * @param {number} page 页码
   * @param {number} pageSize 每页数量
   */
  getGroups(page = 1, pageSize = 20) {
    return request({
      url: `/chat/groups?page=${page}&pageSize=${pageSize}`
    })
  },

  /**
   * 获取我的群组
   */
  getMyGroups() {
    return request({
      url: '/chat/my-groups'
    })
  },

  /**
   * 获取群组详情
   * @param {number} groupId 群组ID
   */
  getGroupDetail(groupId) {
    return request({
      url: `/chat/groups/${groupId}`
    })
  },

  /**
   * 获取群组统计信息
   * @param {number} groupId 群组ID
   */
  getGroupStats(groupId) {
    return request({
      url: `/chat/groups/${groupId}/stats`
    })
  },

  /**
   * 加入群组
   * @param {number} groupId 群组ID
   */
  joinGroup(groupId) {
    return request({
      url: `/chat/groups/${groupId}/join`,
      method: 'POST'
    })
  },

  /**
   * 退出群组
   * @param {number} groupId 群组ID
   */
  leaveGroup(groupId) {
    return request({
      url: `/chat/groups/${groupId}/leave`,
      method: 'POST'
    })
  },

  /**
   * 获取群组成员
   * @param {number} groupId 群组ID
   * @param {number} page 页码
   * @param {number} pageSize 每页数量
   */
  getGroupMembers(groupId, page = 1, pageSize = 50) {
    return request({
      url: `/chat/groups/${groupId}/members?page=${page}&pageSize=${pageSize}`
    })
  },

  /**
   * 发送消息
   * @param {number} groupId 群组ID
   * @param {string} content 消息内容
   * @param {string} messageType 消息类型
   */
  sendMessage(groupId, content, messageType = 'text') {
    return request({
      url: `/chat/groups/${groupId}/messages`,
      method: 'POST',
      data: {
        content,
        message_type: messageType
      }
    })
  },

  /**
   * 获取群组消息
   * @param {number} groupId 群组ID
   * @param {number} page 页码
   * @param {number} pageSize 每页数量
   * @param {number} lastMessageId 最后一条消息ID
   */
  getGroupMessages(groupId, page = 1, pageSize = 50, lastMessageId) {
    let url = `/chat/groups/${groupId}/messages?page=${page}&pageSize=${pageSize}`
    if (lastMessageId) {
      url += `&lastMessageId=${lastMessageId}`
    }
    return request({ url })
  },

  /**
   * 获取新消息（轮询用）
   * @param {number} groupId 群组ID
   * @param {number} lastMessageId 最后一条消息ID
   */
  getNewMessages(groupId, lastMessageId = 0) {
    return request({
      url: `/chat/groups/${groupId}/new-messages?lastMessageId=${lastMessageId}`
    })
  },

  // ==================== 私聊相关API ====================

  /**
   * 发起私聊
   * @param {number} userId 目标用户ID
   */
  startPrivateChat(userId) {
    return request({
      url: `/chat/private/start/${userId}`,
      method: 'POST'
    })
  },

  /**
   * 获取私聊列表
   */
  getPrivateChatList() {
    return request({
      url: '/chat/private/list'
    })
  },

  /**
   * 获取与某用户的私聊消息
   * @param {number} userId 目标用户ID
   * @param {number} page 页码
   * @param {number} pageSize 每页数量
   * @param {number} lastMessageId 最后一条消息ID
   */
  getPrivateChatMessages(userId, page = 1, pageSize = 50, lastMessageId) {
    let url = `/chat/private/${userId}/messages?page=${page}&pageSize=${pageSize}`
    if (lastMessageId) {
      url += `&lastMessageId=${lastMessageId}`
    }
    return request({ url })
  },

  /**
   * 发送私聊消息
   * @param {number} userId 目标用户ID
   * @param {string} content 消息内容
   * @param {string} messageType 消息类型
   */
  sendPrivateMessage(userId, content, messageType = 'text') {
    return request({
      url: `/chat/private/${userId}/messages`,
      method: 'POST',
      data: {
        content,
        message_type: messageType
      }
    })
  },

  /**
   * 获取私聊新消息（轮询用）
   * @param {number} userId 目标用户ID
   * @param {number} lastMessageId 最后一条消息ID
   */
  getPrivateNewMessages(userId, lastMessageId = 0) {
    return request({
      url: `/chat/private/${userId}/new-messages?lastMessageId=${lastMessageId}`
    })
  },

  /**
   * 获取未读私信数量统计
   * @param {number} lastCheckTime 最后查看私信的时间戳
   */
  getUnreadPrivateMessageCount(lastCheckTime) {
    let url = '/chat/private/unread-count'
    if (lastCheckTime) {
      url += `?lastCheckTime=${lastCheckTime}`
    }
    return request({ url })
  },

  // ==================== 全国总群相关API ====================

  /**
   * 获取所有群组的合并消息列表（全国总群功能）
   * @param {number} page 页码
   * @param {number} pageSize 每页数量
   * @param {number} lastMessageId 最后一条消息ID
   */
  getAllGroupsMessages(page = 1, pageSize = 50, lastMessageId) {
    let url = `/chat/all-groups/messages?page=${page}&pageSize=${pageSize}`
    if (lastMessageId) {
      url += `&lastMessageId=${lastMessageId}`
    }
    return request({ url })
  },

  /**
   * 获取所有群组的新消息（全国总群轮询用）
   * @param {number} lastMessageId 最后一条消息ID
   */
  getAllGroupsNewMessages(lastMessageId = 0) {
    return request({
      url: `/chat/all-groups/new-messages?lastMessageId=${lastMessageId}`
    })
  },

  /**
   * 获取所有群组的汇总统计（全国总群统计）
   */
  getAllGroupsStats() {
    return request({
      url: '/chat/all-groups/stats'
    })
  },

  /**
   * 获取所有群组的成员列表（去重，全国总群用）
   * @param {number} page 页码
   * @param {number} pageSize 每页数量
   */
  getAllGroupsMembers(page = 1, pageSize = 50) {
    return request({
      url: `/chat/all-groups/members?page=${page}&pageSize=${pageSize}`
    })
  },

  /**
   * 向指定群组发送消息（新的地区选择发送功能）
   * @param {string} content 消息内容
   * @param {number} groupId 群组ID
   * @param {string} messageType 消息类型
   */
  sendMessageToSelectedGroup(content, groupId, messageType = 'text') {
    return request({
      url: '/chat/groups/send-to-selected',
      method: 'POST',
      data: {
        content,
        group_id: groupId,
        message_type: messageType
      }
    })
  },

  /**
   * 向所有群组发送消息（全国总群发送功能，保留兼容）
   * @param {string} content 消息内容
   * @param {string} messageType 消息类型
   */
  sendMessageToAllGroups(content, messageType = 'text') {
    return request({
      url: '/chat/all-groups/messages',
      method: 'POST',
      data: {
        content,
        message_type: messageType
      }
    })
  }
}

/**
 * 联系方式查看相关API
 */
export const contactViewAPI = {
  /**
   * 检查查看联系方式的权限和费用
   * @param {number} userId 目标用户ID
   */
  checkViewPermission(userId) {
    return request({
      url: `/contact-view/check/${userId}`
    })
  },

  /**
   * 获取用户联系方式
   * @param {number} userId 目标用户ID
   */
  getUserContact(userId) {
    return request({
      url: `/contact-view/user/${userId}`
    })
  },

  /**
   * 获取查看统计
   */
  getViewStats() {
    return request({
      url: '/contact-view/stats'
    })
  },

  /**
   * 获取配置信息
   */
  getConfig() {
    return request({
      url: '/contact-view/config'
    })
  }
}

/**
 * 挂牌信息相关API
 */
export const listingAPI = {
  /**
   * 获取挂牌信息列表
   * @param {Object} params 查询参数
   */
  getListings(params = {}) {
    const queryString = Object.keys(params)
      .map(key => `${key}=${encodeURIComponent(params[key])}`)
      .join('&')
    
    return request({
      url: `/listings${queryString ? '?' + queryString : ''}`
    })
  },

  /**
   * 获取挂牌信息详情
   * @param {number} id 信息ID
   */
  getListingDetail(id) {
    return request({
      url: `/listings/${id}`
    })
  },

  /**
   * 发布挂牌信息
   * @param {Object} listingData 挂牌信息数据
   */
  createListing(listingData) {
    return request({
      url: '/listings',
      method: 'POST',
      data: listingData
    })
  },

  /**
   * 更新挂牌信息
   * @param {number} id 信息ID
   * @param {Object} listingData 更新数据
   */
  updateListing(id, listingData) {
    return request({
      url: `/listings/${id}`,
      method: 'PUT',
      data: listingData
    })
  },

  /**
   * 重新提交审核
   * @param {number} id 信息ID
   */
  resubmitAudit(id) {
    return request({
      url: `/listings/${id}/resubmit-audit`,
      method: 'POST'
    })
  },

  /**
   * 删除挂牌信息
   * @param {number} id 信息ID
   */
  deleteListing(id) {
    return request({
      url: `/listings/${id}`,
      method: 'DELETE'
    })
  }
}

/**
 * 套餐相关API
 */
export const packageAPI = {
  /**
   * 获取套餐列表
   * @param {Object} params 查询参数
   */
  getPackages(params = {}) {
    const queryString = Object.keys(params)
      .map(key => `${key}=${encodeURIComponent(params[key])}`)
      .join('&')

    return request({
      url: `/packages${queryString ? '?' + queryString : ''}`
    })
  },

  /**
   * 获取聊天消息套餐列表
   */
  getChatPackages() {
    return request({
      url: '/packages?type=chat_message'
    })
  },

  /**
   * 获取套餐详情
   * @param {number} id 套餐ID
   */
  getPackageDetail(id) {
    return request({
      url: `/packages/${id}`
    })
  },

  /**
   * 创建订单
   * @param {Object} orderData 订单数据
   */
  createOrder(orderData) {
    return request({
      url: '/orders',
      method: 'POST',
      data: orderData
    })
  },


  /**
   * 获取我的订单
   * @param {Object} params 查询参数
   */
  getMyOrders(params = {}) {
    const queryString = Object.keys(params)
      .map(key => `${key}=${encodeURIComponent(params[key])}`)
      .join('&')

    return request({
      url: `/users/me/orders${queryString ? '?' + queryString : ''}`
    })
  },

  /**
   * 模拟支付
   * @param {number} orderId 订单ID
   * @param {Object} paymentData 支付数据
   */
  mockPayment(orderId, paymentData) {
    return request({
      url: `/orders/${orderId}/mock-payment`,
      method: 'POST',
      data: paymentData
    })
  },

  /**
   * 查询支付状态
   * @param {string} orderNumber 订单号
   */
  getPaymentStatus(orderNumber) {
    return request({
      url: `/payments/status/${orderNumber}`
    })
  }
}

/**
 * 工具方法
 */
export const utils = {
  /**
   * 处理API错误
   * @param {Error} error 错误对象
   * @param {string} defaultMessage 默认错误消息
   */
  handleError(error, defaultMessage = '操作失败') {
    console.error('API错误:', error)

    // 如果是401错误，已经在request方法中处理了，这里不再重复处理
    if (error.message === 'UNAUTHORIZED') {
      return
    }

    let message = defaultMessage
    if (error.message && error.message !== 'UNAUTHORIZED') {
      message = error.message
    }

    uni.showToast({
      title: message,
      icon: 'none',
      duration: 2000
    })
  },

  /**
   * 检查登录状态
   * @returns {boolean}
   */
  isLoggedIn() {
    return !!uni.getStorageSync('token')
  },

  /**
   * 获取当前用户信息
   * @returns {Object|null}
   */
  getCurrentUser() {
    try {
      const userInfo = uni.getStorageSync('userInfo')
      // userInfo 已经是对象，不需要 JSON.parse
      return userInfo || null
    } catch (error) {
      console.error('获取用户信息失败:', error)
      return null
    }
  },

  /**
   * 清除登录信息
   */
  clearAuth() {
    uni.removeStorageSync('token')
    uni.removeStorageSync('userInfo')
  }
}

// ==================== 本地同行API ====================
const localServiceAPI = {
  /**
   * 获取服务分类列表
   */
  getCategories() {
    return request({
      url: '/local-services/categories'
    })
  },

  /**
   * 搜索本地服务
   * @param {Object} params 搜索参数
   */
  searchServices(params = {}) {
    const queryString = Object.keys(params)
      .filter(key => params[key] !== null && params[key] !== undefined && params[key] !== '')
      .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
      .join('&')
    
    return request({
      url: `/local-services/search${queryString ? '?' + queryString : ''}`
    })
  },

  /**
   * 获取服务详情
   * @param {string} serviceId 服务ID
   */
  getServiceDetail(serviceId) {
    return request({
      url: `/local-services/${serviceId}`
    })
  },

  /**
   * 创建服务
   * @param {Object} serviceData 服务数据
   */
  createService(serviceData) {
    return request({
      url: '/local-services',
      method: 'POST',
      data: serviceData
    })
  },

  /**
   * 更新服务
   * @param {string} serviceId 服务ID
   * @param {Object} serviceData 服务数据
   */
  updateService(serviceId, serviceData) {
    return request({
      url: `/local-services/${serviceId}`,
      method: 'PUT',
      data: serviceData
    })
  },

  /**
   * 重新提交审核
   * @param {string} serviceId 服务ID
   */
  resubmitAudit(serviceId) {
    return request({
      url: `/local-services/${serviceId}/resubmit-audit`,
      method: 'POST'
    })
  },

  /**
   * 下架服务
   * @param {string} serviceId 服务ID
   */
  offlineService(serviceId) {
    return request({
      url: `/local-services/${serviceId}/offline`,
      method: 'POST'
    })
  },

  /**
   * 重新上架服务
   * @param {string} serviceId 服务ID
   */
  republishService(serviceId) {
    return request({
      url: `/local-services/${serviceId}/republish`,
      method: 'POST'
    })
  },

  /**
   * 获取我的服务列表
   * @param {Object} params 查询参数
   */
  getMyServices(params = {}) {
    const queryString = Object.keys(params)
      .filter(key => params[key] !== null && params[key] !== undefined && params[key] !== '')
      .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
      .join('&')
    
    return request({
      url: `/local-services/user/my-services${queryString ? '?' + queryString : ''}`
    })
  },

  /**
   * 删除服务
   * @param {string} serviceId 服务ID
   */
  deleteService(serviceId) {
    return request({
      url: `/local-services/${serviceId}`,
      method: 'DELETE'
    })
  },

  /**
   * 点赞/取消点赞服务
   * @param {string} serviceId 服务ID
   */
  toggleLike(serviceId) {
    return request({
      url: `/local-services/${serviceId}/like`,
      method: 'POST'
    })
  },

  /**
   * 发表评论
   * @param {string} serviceId 服务ID
   * @param {string} content 评论内容
   */
  createComment(serviceId, content) {
    return request({
      url: `/local-services/${serviceId}/comments`,
      method: 'POST',
      data: { content }
    })
  },

  /**
   * 获取评论列表
   * @param {string} serviceId 服务ID
   * @param {number} page 页码
   * @param {number} pageSize 每页数量
   */
  getComments(serviceId, page = 1, pageSize = 20) {
    return request({
      url: `/local-services/${serviceId}/comments?page=${page}&pageSize=${pageSize}`,
      method: 'GET'
    })
  },

  /**
   * 上传本地服务图片
   * @param {string} filePath 文件路径
   */
  uploadImage(filePath) {
    return new Promise((resolve, reject) => {
      const token = uni.getStorageSync('token')

      uni.uploadFile({
        url: `${API_CONFIG.baseURL}/local-services/upload-image`,
        filePath: filePath,
        name: 'image',
        header: {
          'Authorization': token ? `Bearer ${token}` : ''
        },
        success: (res) => {
          try {
            const data = JSON.parse(res.data)
            if (data.success) {
              resolve(data)
            } else {
              reject(new Error(data.message || '上传失败'))
            }
          } catch (error) {
            reject(new Error('响应解析失败'))
          }
        },
        fail: (error) => {
          reject(error)
        }
      })
    })
  },

  /**
   * 获取数据一致性报告 (管理员功能)
   */
  getConsistencyReport() {
    return request({
      url: '/local-services/admin/consistency-report'
    })
  },

  /**
   * 修复计数数据 (管理员功能)
   */
  fixCounts() {
    return request({
      url: '/local-services/admin/fix-counts',
      method: 'POST'
    })
  }
}

// ==================== 服务保证金API ====================
const serviceDepositAPI = {
  /**
   * 获取保证金余额
   */
  getBalance() {
    return request({
      url: '/service-deposits/balance'
    })
  },

  /**
   * 获取保证金记录
   * @param {Object} params 查询参数
   */
  getRecords(params = {}) {
    const queryString = Object.keys(params)
      .filter(key => params[key] !== null && params[key] !== undefined && params[key] !== '')
      .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
      .join('&')
    
    return request({
      url: `/service-deposits/records${queryString ? '?' + queryString : ''}`
    })
  },

  /**
   * 充值保证金
   * @param {Object} depositData 充值数据
   */
  deposit(depositData) {
    return request({
      url: '/service-deposits/deposit',
      method: 'POST',
      data: depositData
    })
  },

  /**
   * 申请退款
   * @param {Object} refundData 退款数据
   */
  refund(refundData) {
    return request({
      url: '/service-deposits/refund',
      method: 'POST',
      data: refundData
    })
  },

  /**
   * 模拟支付成功（开发环境）
   * @param {Object} paymentData 支付数据
   */
  mockPaymentSuccess(paymentData) {
    return request({
      url: '/service-deposits/payment/mock-success',
      method: 'POST',
      data: paymentData
    })
  }
}

// 导出新的API模块
export { localServiceAPI, serviceDepositAPI }

// 默认导出通用request方法
export default {
  request,
  getBaseURL: () => API_CONFIG.baseURL,
  // 便捷方法
  getUserInfo: () => userAPI.getCurrentUser(),
  markAuditViewed: (type, id) => userAPI.markAuditViewed(type, id),
  // API模块
  auth: authAPI,
  user: userAPI,
  chat: chatAPI,
  contactView: contactViewAPI,
  listing: listingAPI,
  package: packageAPI,
  utils: utils,
  localService: localServiceAPI,
  serviceDeposit: serviceDepositAPI
}
